package com.caocaog.market.data.transfer.service.impl;

import cn.hutool.core.convert.Convert;
import cn.hutool.http.HttpUtil;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.incrementer.DefaultIdentifierGenerator;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.caocaog.market.data.transfer.entity.CcUser;
import com.caocaog.market.data.transfer.entity.MkSysUser;
import com.caocaog.market.data.transfer.mapper.CcTestMapper;
import com.caocaog.market.data.transfer.mapper.MkSysUserMapper;
import com.caocaog.market.data.transfer.mapper.MkTestMapper;
import com.caocaog.market.data.transfer.service.MkSysUserService;
import com.caocaog.market.data.transfer.service.MkTestService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.DateUtils;
import org.jeecg.common.util.PasswordUtil;
import org.jeecg.common.util.oConvertUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.*;

/**
 * @author liguang
 * @version 1.0.0
 * @Project jeecg-boot
 * @Package com.caocaog.market.data.transfer.service.impl
 * @ClassName MkSysUserServiceImpl.java
 * @createTime 2021年11月16日 10:07:00
 * @Description TODO
 */
@Service
@Slf4j
public class MkTestServiceImpl  implements MkTestService {
    @Autowired
    private CcTestMapper ccTestMapper;
    @Autowired
    private MkTestMapper mkTestMapper;

    /**
     * 拉取商家数据
     * @return
     */
    @Override
    public String insertMerchant() {
        List<Map<String,Object>> shops = ccTestMapper.findAllShopInfo();
        //log.info("已审核的商家（门店）总共有多少条数据：：：："+shops.size());
        log.info("待审核的商家（门店）总共有多少条数据：：：："+shops.size());
        String[] merchants = new String[]{"hanshouxian","baoshan","suiningxian"};
        int success=0,noSite=0,yjdccll=0,error=0;
        Date nowDate = DateUtils.getDate();
        for (Map<String,Object> map: shops){
            // id
            String id = String.valueOf(map.get("sid"));
            // 身份证号
            String cardNo = String.valueOf(map.get("idCardNo"));
            // 手机号
            String mobile = String.valueOf(map.get("mobile"));
            // 身份证反面
            String fmImg = String.valueOf(map.get("fmImg"));
            // 支付宝账号
            String aliNo = String.valueOf(map.get("aliNo"));
            // 商家登录名账号
            String loginName = String.valueOf(map.get("loginName"));
            loginName  = Arrays.asList(merchants).contains(loginName) ? loginName+"a" : loginName;
            // 商家姓名
            String name = String.valueOf(map.get("name"));
            // 先存商家账号登录信息
            // 先根据loginName查询系统中有没有该用户
            int count = mkTestMapper.findForUsername(loginName);
            if(count>0){
                loginName = loginName+"a";
            }
            mkTestMapper.insertSysUser(IdWorker.getIdStr(),loginName,name,mobile,nowDate);
            // 根据loginName查询sys_user表中的id
            String userId = mkTestMapper.findUserId(loginName);
            //如果该商家已经拉过来了，就不再拉了(根据id去mk_merchant_basic表中查询，因为拉取过来的数据中的id和mk_merchang_basic表中的id是一样的)
            if(mkTestMapper.findMerchantCountByUserId(id)>0){
                String userIdagain = mkTestMapper.findUserId(loginName);
                if(mkTestMapper.findMerchantCountByUserId(userIdagain)>0){
                    log.info("该商家已经拉到曹操来了系统；原系统商家数据："+JSONUtil.toJsonStr(map));
                    yjdccll = yjdccll+1;
                    continue;
                }
            }
            // 商家所属跑腿系统代理商id
            int agentSid = Integer.parseInt(String.valueOf(map.get("agentSid")));
            // 根据原代理商id查询现系统中的分站id
            String siteId = mkTestMapper.findSiteId(agentSid);
            if(StringUtils.isBlank(siteId)){
                log.info("分站id为空，不进行数据迁移；原系统商家数据："+JSONUtil.toJsonStr(map));
                noSite = noSite + 1;
                continue;
            }
            // 身份证正面
            String zmImg = String.valueOf(map.get("zmImg"));
            // 支付宝姓名
            String aliName = String.valueOf(map.get("aliName"));
            // 手持身份证照片
            String handImg = String.valueOf(map.get("handImg"));

            // 审核状态
            int state = Integer.parseInt(String.valueOf(map.get("auditStatus")));
            // 转移到曹操来了库中的商家信息的id和曹操跑腿库中的商家信息id是一样的
           try{
               mkTestMapper.insertMerchant(id,name,cardNo,zmImg,fmImg,handImg,mobile,state,aliNo,aliName,siteId,userId, nowDate);
               log.info("数据拉取成功，原商家数据："+JSONUtil.toJsonStr(map));
               success = success + 1;
           }catch (Exception e){
               log.info("数据摘取失败，原商家数据："+JSONUtil.toJsonStr(map));
               error = error + 1;
           }
        }
        return "总共有："+shops.size()+" 条数据，其中摘取成功"+success+"条数据，在新系统中找不到分站的有"+noSite+"条数据，之前已经拉过来的有 "+yjdccll+" 条数据，数据正常但是摘取失败 "+error+" 条数据";
    }

    @Override
    public String insertShop() {
        List<Map<String,Object>> shops = ccTestMapper.findAllShops();
        //log.info("已审核的门店（商家）总共有多少条数据：：：："+shops.size());
        log.info("待审核的门店（商家）总共有多少条数据：：：："+shops.size());
        // 转移成功多少条
        int success = 0;
        // 已转到曹操来了
        int yjdccll = 0;
        // 数据转移出错
        int error = 0;
        // 账号绑定成功
        int bindSuc = 0;
        // 账号绑定失败
        int bindErr = 0;
        // 账号已绑定
        int binded = 0;
        Date nowDate = DateUtils.getDate();
        for (Map<String,Object> map: shops){
            // sid as merchantId,shop_name as shopName,ali_name aliName,ali_no aliNo,royalty,shop_logo as shopLogo,shop_license shopLicense,
            // " +
            //            "send_order_type as sendOrderType,audit_status as auditStatus,
            //            member_sid as memberSid,longitude,latitude,is_working as isWork," +
            //            "adcode,city_name as cityName,address,address_aoi as addressAoi,is_recommend isRecommend
            // 商家id
            String merchantId = String.valueOf(null==map.get("merchantId")?"":map.get("merchantId"));
            // 查询该商家id在mk_merchant_basic表中是否存在
            if(mkTestMapper.findMerchantCountByUserId(merchantId)<1){
                log.info("商家账号不存在----》 "+merchantId);
                continue;
            }
            // 门店名称
            String shopName = String.valueOf(null==map.get("shopName")?"":map.get("shopName"));
            // 支付宝账号
            String alino =  String.valueOf(null==map.get("aliNo")?"":map.get("aliNo"));
            // 支付宝姓名
            String aliName =  String.valueOf(null==map.get("aliName")?"":map.get("aliName"));
            // 平台抽成
            BigDecimal royalty = new BigDecimal(String.valueOf(null==map.get("royalty")?"":map.get("royalty")));
            // logo
            String logo =  String.valueOf(null==map.get("shopLogo")?"":map.get("shopLogo"));
            // 营业执照
            String shopLicense = String.valueOf(null==map.get("shopLicense")?"":map.get("shopLicense"));
            // 发单方式
            String sendOrderType = String.valueOf(null==map.get("sendOrderType")?"":map.get("sendOrderType"));
            //绑定跑腿的账号id（cc_member表中的id）
            int memberSid = Integer.parseInt(String.valueOf(null==map.get("memberSid")?"":map.get("memberSid")));
            // 门店经度
            String longitude = String.valueOf(null==map.get("longitude")?"":map.get("longitude"));
            // 门店纬度
            String latitude = String.valueOf(null==map.get("latitude")?"":map.get("latitude"));
            // 营业状态 1：正常营业，2：休息中（打样）
            String isWork = String.valueOf(null==map.get("isWork")?"":map.get("isWork"));
            // 对于mk_shop_basic来说，0营业   1休息
            int isRest = isWork.equals("1") ? 0 : 1 ;
            // 所属城市
            String cityName = String.valueOf(null==map.get("cityName")?"":map.get("cityName"));
            // 门店详细地址
            String address = String.valueOf(null==map.get("address")?"":map.get("address"));
            // 门店地址
            String addressAoi = String.valueOf(null==map.get("addressAoi")?"":map.get("addressAoi"));
            //是否推荐 1表示是
            String isRecommend = String.valueOf(null==map.get("isRecommend")?"0":map.get("isRecommend"));
            // 详细地址：
            String addressText = cityName+addressAoi+address;
            String shopId = merchantId;
            // 营业开始时间
            int start = Integer.parseInt(String.valueOf(map.get("tart")));
            String businessStd = (start<10?"0"+start:start) +":00";
            // 营业结束时间
            int end = Integer.parseInt(String.valueOf(map.get("nd")));
            String businessEnd = (end<10?"0"+end:end) +":00";
            // 店铺评分
            String score = String.valueOf(null==map.get("score")?"":map.get("score"));
            // 店铺类型    0是没有，1周边美食，2酒水饮料，3两性用品，4水果生鲜，5幼儿母婴，
            //              6火锅冒菜，7啤酒烧烤，8鲜花绿植，
            //              9 蛋糕甜点，10宠物家禽
            int shopType = Integer.parseInt(String.valueOf(map.get("shopType")));
            // 对应关系：1 6 7 全部对应周边美食
            //          2  对应  中外名酒
            //          3  对应  两性用品
            //          4   对应  蔬菜水果
            //          0 5 10   对应  综合超市
            //          8   对应  浪漫鲜花
            //          9   对应  蛋糕西点
            // 频道
            String channelId = mkTestMapper.findChannelId(findTypeStr(shopType));
            // 门店状态：
            int audit = Integer.parseInt(String.valueOf(map.get("auditStatus")));
            // 先查询该门店是否已插入到mk_shop_basic表中
            if(mkTestMapper.findShopIsExists(shopId)<1){
                // 插入门店数据
               int i= mkTestMapper.insShop(shopId,nowDate,merchantId,shopName,logo,businessStd,businessEnd,isRest,shopLicense,String.valueOf(royalty),isRecommend,
                        longitude,latitude,"","","",address,addressAoi,addressText,channelId,aliName,alino,audit,score);
                if(i>0){
                    success = success+1;
                    // 处理账号绑定的问题
                    String loginName = ccTestMapper.findMemberLoginName(memberSid);
                    if(mkTestMapper.findBinded(shopId)<1 && StringUtils.isNotBlank(loginName)){
                        // 存账号绑定
                        String bindId = IdWorker.getIdStr();
                        int j = mkTestMapper.insertBindShopMember(bindId,nowDate,merchantId,shopId,String.valueOf(memberSid),loginName);
                        if(j>0){
                            log.info("账号绑定成功");
                            bindSuc = bindSuc + 1;
                        }else{
                            log.info("账号绑定失败---》 sqlserver库中的memberSid = "+memberSid);
                            bindErr = bindErr + 1;
                        }
                    }else{
                        binded = binded+1;
                    }
                    // 处理配送距离设置
                    // 最大配送距离max_dis，免费配送距离free_send，配送时长send_time_avg，人均消费consume_avg，店铺总销量sale_count，发单方式send_order_type，打包费pack_price，起送价格send_need_money，
                    // 免费配送条件send_free_money
                    // 最大配送距离
                    String mxDistance = String.valueOf(map.get("maxDis"));
                    // 免费配送距离
                    String freeDistance = String.valueOf(map.get("freeSend"));
                    Object sendTimeAvgObj = map.get("sendTimeAvg");
                    // 配送时长
                    String  duration = "";
                    if(null!=sendTimeAvgObj){
                        duration = String.valueOf(sendTimeAvgObj);
                    }
                    Object consumeAvgObj = map.get("consumeAvg");
                    // 人均消费
                    String perCost = "";
                    if(null!=consumeAvgObj){
                        perCost = String.valueOf(consumeAvgObj);
                    }
                    Object saleCount = map.get("saleCount");
                    // 自定义销量
                    int textTotal = 0;
                    if(null!=saleCount){
                        textTotal = Integer.parseInt(String.valueOf(saleCount));
                    }
                    Object sendOrderTypeObj = map.get("sendOrderType");
                    // 订单配送模式，1手动发单  2自动发单
                    String orderModel = "2";
                    if(null!=sendOrderTypeObj && String.valueOf(sendOrderTypeObj).equals("1")){
                        orderModel = "1";
                    }
                    Object packPriceObj = map.get("packPrice");
                    // 店铺统一打包费
                    String pack = "0";
                    if(null!=packPriceObj){
                        pack = String.valueOf(packPriceObj);
                    }
                    // 起送价格
                    String startFare = String.valueOf(map.get("sendNeedMoney"));
                    // 免费配送条件
                    Object freeDistributionObj = map.get("freeDistribution");
                    String freeDistribution = null==freeDistributionObj ? "0" : String.valueOf(freeDistributionObj);
                    String shoptakeoutId = shopId;
                    mkTestMapper.insertShopTakeout(shoptakeoutId,nowDate,shopId,textTotal,duration,perCost,startFare,freeDistribution,mxDistance,freeDistance,pack,orderModel,channelId);
                }else{
                    error=error+1;
                }
            }else{
                yjdccll = yjdccll+1;
            }
        }
        return "原曹操来了系统中，总共有"+shops.size()+"条待审核的门店，其中  转移成功："+success+"条，失败："+error+"条，现系统中之前已转移："+yjdccll+"条；" +
                "账号绑定成功："+bindSuc+"条，绑定失败："+bindErr+"条，现系统中之前已绑定："+binded+"条";
    }

    /**
     * 拉取所有商品的分类(根据已拉过来的门店id查询跑腿系统中的商品分类)
     */
    @Override
    public String pullClassify() {
        List<Integer> allShopIds = mkTestMapper.findAllShopIds();
        String str ="";
        // 所有商品分类的数量
        int allGoodsNum = 0;
        // 所有门店的数量
        int shopNum=0;
        // 没有商品的门店数量
        int noGoodsNum = 0;
        String noGoodsShopIds="没有商品的门店id：";
        Date nowDate = DateUtils.getDate();
        // 总共转移成功多少条数据
        int success=0;
        // 总共转移失败多少条数据
        int error = 0;
        // 之前系统中已转移的数据
        int yjy = 0;
        for(int i=0;i<allShopIds.size();i++){
            shopNum = shopNum+1;
            int shopId = allShopIds.get(i);
            List<Map<String,Object>> shopGoods = ccTestMapper.findGoodsClassify(shopId);
            str =str+ "门店id="+shopId+"，该门店总共查询到"+shopGoods.size()+"条商品分类数据； ";
            if(shopGoods.size()<1){
                noGoodsNum = noGoodsNum + 1;
                noGoodsShopIds = noGoodsShopIds + shopId;
                continue;
            }
            for (Map<String,Object> map:shopGoods){
                allGoodsNum = allGoodsNum + 1 ;
                // sid,name,remark,is_show as isShow,sort
                String id = String.valueOf(map.get("sid"));
                String name = String.valueOf(map.get("name"));
                String mark = String.valueOf(map.get("remark"));
                String isShow = String.valueOf(map.get("isShow"));
                int sort = Integer.parseInt(String.valueOf(map.get("sort")));
                if(mkTestMapper.findSortById(id)<1){
                    try{
                        mkTestMapper.insertGoodsSort(id,nowDate,String.valueOf(shopId),name,mark,sort,isShow);
                        success = success+1;
                    }catch (Exception e){
                        error = error+1;
                    }
                }else{
                    yjy = yjy+1;
                }
            }
        }
        log.info(str);
        String st = "总共有"+shopNum+"个门店；所有门店的商品分类总共有："+allGoodsNum+"条; "+noGoodsNum+"个门店没有商品分类";
        log.info(st);
        String info = "总共有"+allGoodsNum+"条分类数据，转移成功"+success+"条分类数据，之前已转移过"+yjy+"条分类数据，转移失败："+error+"条分类数据；";
        log.info(info);
        return str+"------"+st+"----"+noGoodsShopIds+"-----"+info;
    }

    /**
     * 拉取所有商品的数据（根据已拉过来的门店id查询跑腿系统中的商品数据）
     * @return
     */
    @Override
    public String pullGoods() {
        /**
         * 先查询已拉到曹操来了系统中已经拉过来的门店的id(门店id对应曹操跑腿系统中的门店id)
         */
        List<Integer> allShopIds = mkTestMapper.findAllShopIds();
        String str ="";
        // 所有商品的数量
        int allGoodsNum = 0;
        // 所有门店的数量
        int shopNum=0;
        // 没有商品的门店数量
        int noGoodsNum = 0;
        // 迁移成功
        int suc = 0;
        //迁移失败
        int err = 0;
        String noGoodsShopIds="没有商品的门店id：";
        Date nowDate = DateUtils.getDate();
        for(int i=0;i<allShopIds.size();i++){
            shopNum = shopNum+1;
            int shopId = allShopIds.get(i);
            List<Map<String,Object>> shopGoods = ccTestMapper.allGoods(shopId);
            str =str+ "门店id="+shopId+"，该门店总共查询到"+shopGoods.size()+"条商品数据； ";
            allGoodsNum = allGoodsNum+shopGoods.size();
            if(shopGoods.size()<1){
                noGoodsNum = noGoodsNum + 1;
                noGoodsShopIds = noGoodsShopIds + shopId;
                continue;
            }
            /** 解析数据----开始 */
            for (Map<String,Object> map:shopGoods){
                // 商品id
                String id = String.valueOf(map.get("sid"));
                // 门店id
                String shop_id = String.valueOf(map.get("shopSid"));
                // 商品名称
                String name = String.valueOf(map.get("name"));
                // 商品售价
                String presentPrice = null== map.get("price") ? "0" : String.valueOf(map.get("price"));
                // 商品原价
                String originalPrice = null==map.get("mPrice") ? "" : String.valueOf(map.get("mPrice"));
                // 商品图片
                String picture = null==map.get("logo") ? "" : String.valueOf(map.get("logo"));
                // 商品简称
                String shortName = null==map.get("shortName") ? "" : String.valueOf(map.get("shortName"));
                //商品编码
                String code = null==map.get("code") ? "" : String.valueOf(map.get("code"));
                // 商品完整描述
                String description = null==map.get("shortDesc") ? "" : String.valueOf(map.get("shortDesc"));
                // 商品简短描述
                String shortDescription = description;
                // 商品上下架状态
                String sxjzt = null==map.get("sxjzt") ? "" : String.valueOf(map.get("sxjzt"));
                String status = "1"; // 1上架
                if(!sxjzt.equals("1")){
                    status="0";  // 下架
                }
                // 是否首页展示  1是 0否   和sqlserver库是保持一致的
                String isIndex = null==map.get("isIndex") ? "" : String.valueOf(map.get("isIndex"));
                //是否热门产品 1是  0否    和sqlserver库是保持一致的
                String isHot =  null==map.get("isHot") ? "" : String.valueOf(map.get("isHot"));
                String sorts = "";
                // 商品分类
                String classify1 =  null==map.get("classify1") ? "" : String.valueOf(map.get("classify1"));
                if(StringUtils.isNotBlank(classify1) && !classify1.equals("0")){
                    // 存商品分类表数据
                    String sortsInfoId1 = IdWorker.getIdStr();
                    mkTestMapper.insertSortInfo(sortsInfoId1,nowDate,classify1,id);
                    sorts = sorts + sortsInfoId1+",";
                }
                String classify2 =  null==map.get("classify2") ? "" : String.valueOf(map.get("classify2"));
                if(StringUtils.isNotBlank(classify2) && !classify2.equals("0")){
                    String sortsInfoId2 = IdWorker.getIdStr();
                    // 存商品分类表数据
                    mkTestMapper.insertSortInfo(sortsInfoId2,nowDate,classify2,id);
                    sorts = sorts + sortsInfoId2+",";
                }
                String classify3 =  null==map.get("classify3") ? "" : String.valueOf(map.get("classify3"));
                if(StringUtils.isNotBlank(classify3) && !classify3.equals("0")){
                    String sortsInfoId3 = IdWorker.getIdStr();
                    // 存商品分类表数据
                    mkTestMapper.insertSortInfo(sortsInfoId3,nowDate,classify3,id);
                    sorts = sorts + sortsInfoId3+",";
                }
                if(sorts.trim().length()>1){
                    sorts = sorts.substring(0,sorts.length()-1);
                }
                // 浏览次数
                int visitNum = Integer.parseInt(null==map.get("vistiCount") ? "0" : String.valueOf(map.get("vistiCount")));
                // 销售数量
                int saleNum = Integer.parseInt(null==map.get("saleCount") ? "0" : String.valueOf(map.get("saleCount")));
                // 存商品
                if(mkTestMapper.findGoodsIsExists(id)<1){
                    int n = mkTestMapper.insertGoodsBasic(id,nowDate,name,shortName,sorts,originalPrice,presentPrice,code,picture,description,shortDescription,
                            status,isIndex,isHot,visitNum,saleNum,shop_id);
                    if(n>0){suc = suc+1;}else{err = err+1;}
                }else{
                    // 该商品已迁移
                    continue;
                }
                // 商品属性
                String skuJson = String.valueOf(null==map.get("skuJson") ? "" : String.valueOf(map.get("skuJson")));
                skuJson = skuJson.trim();
                if(skuJson.length()>2){
                    List<Map<String,String>> list = change(skuJson);
                    for (Map<String,String> mm :list){
                        for(Map.Entry<String, String> vo : mm.entrySet()){
                            String key = vo.getKey();
                            String value = vo.getValue();
                            // 存商品属性
                            String attributeId = IdWorker.getIdStr();
                            mkTestMapper.insertGoodsAttribute(attributeId,nowDate,id,key,value);
                        }
                    }
                }else{
                    // 没有商品属性
                }
                // 商品规格
                List<Map<String, Object>>  ggs = ccTestMapper.findSkuByGoodsId(Integer.parseInt(id));
                if(ggs.size()<1){
                    continue;
                }
                for (Map<String,Object> gg:ggs){
                    // 规格id
                    String ggId = gg.get("sid").toString();
                    // 规格名称
                    String ggName = null==gg.get("name") ? name : gg.get("name").toString();
                    // 规格描述
                    String ggDescription = null==gg.get("shortDesc") ? "" : gg.get("shortDesc").toString();
                    //规格售价
                    String ggPrice = String.valueOf(null==gg.get("price") ? "" : gg.get("price").toString());
                    //规格打包费
                    String ggPackPrice = String.valueOf(null==gg.get("packPrice") ? "" : gg.get("packPrice").toString());
                    //规格打包费
                    String ggPicture = String.valueOf(null==gg.get("logo") ? "" : gg.get("logo").toString());
                    //规格库存
                    int ggStock = Integer.parseInt(null==gg.get("stock") ? "0" : gg.get("stock").toString());
                    // 规格重量
                    String ggWeight = String.valueOf(null==gg.get("weight") ? "0" : gg.get("weight").toString());
                            // sid,name,short_desc,price,pack_price packPrice,logo,stock,weight
                    if(mkTestMapper.findSpecificationsById(ggId)<1){
                        mkTestMapper.insertSpecifications(ggId,nowDate,id,ggName,ggDescription,ggPrice,ggWeight,ggStock,ggPackPrice,ggPicture);
                    }
                }
               /* sid,shop_sid as shopSid,name,price,m_price as mPrice,pm_price as pmPrice,logo,short_name as shortName," +
                "code,short_desc as shortDesc,status as sxjzt,is_index as isIndex,is_hot as isHot,classify1,classify2,classify3," +
                        "visti_count as vistiCount,sale_count as saleCount,sku_desc_json as skuJson*/
            }
        }
        log.info(str);
        String st = "总共有"+shopNum+"个门店；所有门店的商品总共有："+allGoodsNum+"条,迁移成功："+suc+",迁移失败："+err+"; "+noGoodsNum+"个门店没有商品";
        log.info(st);
        return str+"------"+st+"----"+noGoodsShopIds;
    }

    /**
     * 将拉取过来的商品数据，存历史表
     *      1、查询商品数据列表（从表mk_goods_basic表中查询）
     *      2、查询出商品所对应的属性（mk_goods_attribute）转换成json数组  存mk_goods_his表中的goods_attribute字段
     *      3、查询出商品所对应的规格（mk_goods_specifications）转换成json数组 存mk_goods_his表中goods_specifications字段
     *      4、更新 mk_goods_his 表中 mk_goods_attribute字段   和 mk_goods_specifications字段【存：已手动存 mk_goods_his(商品表)】
     */
    @Override
    public String updateGoodsHis() {
        List<Map<String ,String>> goods = mkTestMapper.findMkGoodsHis();
        for (Map<String,String> gds : goods){
            String id = gds.get("id");
            String goodsId = gds.get("goodsId");
//            if(!(goodsId.equals("1141") || goodsId.equals("100"))){
//                continue;
//            }
            // 查询商品属性
            List<Map<String,Object>> attrs = mkTestMapper.findGoodsAttrByGoodsId(goodsId);
            JSONArray arr = JSONUtil.parseArray(JSONUtil.toJsonStr(attrs));
            String attrArrStr = JSONUtil.toJsonStr(arr);

            // 查询商品规格
            List<Map<String,Object>> specs = mkTestMapper.findGoodsSpecByGoodsId(goodsId);
            JSONArray specArr = JSONUtil.parseArray(JSONUtil.toJsonStr(specs));
            String specArrStr = JSONUtil.toJsonStr(specArr);
            mkTestMapper.updateGoodsHisAttrAndSpec(attrArrStr,specArrStr,id);
            log.info("goodsId = "+goodsId+"     商品属性 = "+attrArrStr+"   商品规格 = "+specArrStr);
        }

        return "成功";
    }

    /**
     * 订单数据转移（根据已拉过来的门店id查询跑腿系统中的订单数据）
     */
    @Override
    public String pullOrder() {
        /**
         * 先查询已拉到曹操来了系统中已经拉过来的门店的id(门店id对应曹操跑腿系统中的门店id)
         */
        List<Integer> allShopIds = mkTestMapper.findAllShopIds();
        // 返回的字符串
        String str ="";
        // 所有订单的数量
        int allOrdersNum = 0;
        // 所有门店的数量
        int shopNum=0;
        // 没有订单的门店数量
        int noOrderShopNum = 0;
        // 迁移成功
        int suc = 0;
        //迁移失败
        int err = 0;
        // 支付信息保存成功
        int payInfoSuc=0;
        // 没有支付信息
        int noPayInfo=0;
        Date nowDate = DateUtils.getDate();
        for (int shopId : allShopIds){
            shopNum = shopNum+1;
            // 根据门店id查询该门店在原“曹操来了”系统中有多少订单；查询的是没有被删除的订单
            List<Map<String,Object>>  ccShopOrders = ccTestMapper.findCcOrders(shopId);
            if(null==ccShopOrders || ccShopOrders.size()<1){
                log.info("门店id："+shopId+"，没有订单；");
                noOrderShopNum = noOrderShopNum+1;
                continue;
            }else{
                allOrdersNum = allOrdersNum + 1;
                // 解析订单数据
                for (Map<String,Object> map : ccShopOrders){
                    // 订单id
                    String id = String.valueOf(map.get("sid"));
                    // 曹操跑腿代理商id
                    int agentSid = Integer.parseInt(String.valueOf(map.get("agentSid")));
                    // 查询新系统中分站id
                    String siteId = mkTestMapper.findMkSiteIdByAgentSid(agentSid);
                    // 门店id
                    int shopSid = Integer.parseInt(String.valueOf(map.get("shopSid")));
                    //查询新系统中的merchantId
                    String merchantId = mkTestMapper.findMerchantIdByShopId(String.valueOf(shopSid));
                    // 订单号
                    String orderNo = String.valueOf(map.get("orderNo"));
                    // 类型  orderType 1：配送，2：自提，3：快递物流;
                    // 目前sqlserver库里面的数据，只有 1 和 2 ，和现在系统内的类型是对应的
                    // 曹操来了  现在系统内   类型  type ：类型1：外卖 2：自提 3：店内
                    int type = Integer.parseInt(String.valueOf(map.get("orderType")));

                    // 订单状态
                    // 目前sqlserver库里面的数据  的状态：0（待付款）  1（支付成功待接单）  2（已接单）   4（已取货/配送中）   5（已送达）   12（商家同意退款）
                    // 曹操来了 现在系统内   状态 status： -3:退款成功-2:申请售后-1:取消订单0:待付款1:待发货(待核销)2:待收货3:已完成
                    int orderStatus = Integer.parseInt(String.valueOf(map.get("orderStatus")));
                    String status="0";
                    if(orderStatus==1){
                        status = "1";
                    }else if(orderStatus==2 || orderStatus==4){
                        status="2";
                    }else if(orderStatus==5){
                        status="3";
                    }else if(orderStatus==12){
                        status="-3";
                    }
                    // 订单来源（sqlserver库中所用到的值：1：IOS客户端，2：Android客户端，3：微信小程序，4：PC下单）
                    // 目前sqlserver库中的值：   只有3微信小程序
                    // 曹操来了  现在系统内   的来源   ：1:微信小程序 2：支付宝小程序 3：安卓APP 4:IOSAPP
                    int source = 3;
                    // 订单备注
                    String remark = String.valueOf(map.get("remark"));

                    /**
                     * 存订单数据
                     */
                    String orderId = id;
                    // 下单客户的id
                    String memberId = String.valueOf(map.get("memberSid"));
                    int num = mkTestMapper.insertMkOrder(id,nowDate,siteId,merchantId,String.valueOf(shopId),orderNo,type,status,source,remark,memberId);
                    if(num>0){
                        suc = suc+1;
                        log.info("订单转移成功，开始存配送信息");
                        //存订单行信息
                        // 根据订单id查询该订单的的订单行（也就是该订单包含哪些商品）
                        List<Map<String,Object>> ccOrderInfos = ccTestMapper.findCcOrderInfo(Integer.parseInt(orderId));
                        if(null != ccOrderInfos && ccOrderInfos.size()>0){
                            for(Map<String,Object> orderInfo : ccOrderInfos){
                                // 订单行id
                                String lineId = String.valueOf(orderInfo.get("sid"));
                                //商品id
                                String goodsHisId = String.valueOf(orderInfo.get("goodsSid"));
                                //商品名称
                                String goodsName = String.valueOf(orderInfo.get("goodsName"));
                                //商品logo
                                String goodsLogo = String.valueOf(orderInfo.get("goodsLogo"));
                                // 规格id
                                String specHisId = String.valueOf(orderInfo.get("goodsSkuSid"));
                                // 数量
                                int quantity = Integer.parseInt(String.valueOf(orderInfo.get("buyCount")));
                                // 价格
                                String totalPrice = String.valueOf(orderInfo.get("totalMoney"));
                                // 订单备注
                                String orderRemark = String.valueOf(orderInfo.get("remark"));
                                // 商品规格名称
                                String nameStr = String.valueOf(orderInfo.get("goodsSkuName"));
                                // 商品名称
                                String  spName = String.valueOf(orderInfo.get("goodsName"));
                                // 存订单行信息
                                mkTestMapper.insertMkOrderLine(lineId,nowDate,orderId,orderNo,goodsHisId,specHisId,quantity,totalPrice,remark,nameStr,spName);
                            }
                        }
                        // 存配送信息
                        String deliveryId = id;
                        // 收货人姓名
                        String name = String.valueOf(map.get("receiptName"));
                        // 收货人手机号
                        String mobile = String.valueOf(map.get("receiptMobile"));
                        // 收货人地址
                        String location = String.valueOf(map.get("receiptAddrAoi"));
                        // 收货人详细地址
                        String address =  String.valueOf(map.get("receiptAddrAoi"))+String.valueOf(map.get("receiptAddr"))+String.valueOf(map.get("receiptAddrHouse"));
                        // 收货人经度
                        String lng = String.valueOf(map.get("receiptLon"));
                        // 收货人纬度
                        String lat = String.valueOf(map.get("receiptLat"));
                        // 距离
                        String distance = String.valueOf(map.get("orderDis"));
                        // 配送费
                        String deliveryAmount = String.valueOf(map.get("sendPrice"));
                        // 存配送信息
                        if(StringUtils.isNotBlank(name)&& StringUtils.isNotBlank(mobile)){
                            // 收货人姓名和电话都不为空的情况下才会存配送信息
                            mkTestMapper.insertMkOrderDelivery(deliveryId,nowDate,orderId,name,mobile,location,address,lng,lat,distance,deliveryAmount);
                        }

                        // 存支付信息
                        String orderPayId = orderId;
                        // 支付状态  目前sqlserver库中只有两种状态：0待支付    1支付成功
                        int payStatus = Integer.parseInt(String.valueOf(map.get("payStatus")));
                        // 支付方式：目前sqlserver库中只有一个值：2  微信
                        int payWay = Integer.parseInt(String.valueOf(map.get("payWay")));
                        // 支付流水号
                        String paySerno  = String.valueOf(null==map.get("paySerno")?"":map.get("paySerno"));
                        // 支付时间
                        Date payTime = null==map.get("payTime")?null:(Date)map.get("payTime");
                        // 优惠金额
                        String discountAmount = String.valueOf(map.get("discounts"));
                        // 配送费，上面已经解析，deliveryAmount
                        // 打包费，packAmount
                        String packAmount = null==map.get("packPrice")?"":String.valueOf(map.get("packPrice"));
                        // 实际支付金额
                        String payAmount = String.valueOf(map.get("payAmount"));
                        // 支付结果集()
                        String endPayInfo = "数据转移过来的";
                        if(payStatus==1){
                            //  存支付信息
                            mkTestMapper.insertMkOrderPay(orderPayId,nowDate,orderId,payStatus,payWay,paySerno,payTime,payAmount,discountAmount,deliveryAmount,packAmount,payAmount,endPayInfo);
                            log.info("有支付信息，支付信息保存成功！");
                            payInfoSuc = payInfoSuc + 1;
                        }else{
                            //不存支付信息
                            log.info("没有支付信息，不需要保存支付信息");
                            noPayInfo = noPayInfo + 1;
                        }

                    }else{
                        err = err+1;
                    }
                }
            }
        }


        return "共有"+shopNum+"门店，其中没有订单的门店有"+noOrderShopNum+"，总共有 "+allOrdersNum+"订单数据，订单迁移成功："+suc+"迁移失败："+err+"；订单中  有支付信息并且转移成功："+payInfoSuc+",没有支付信息："+noPayInfo;
    }

    /**
     * 修改转移过来的商家用户的密码
     * @return
     */
    @Override
    public String updatePassword() {
        int suc=0;
        int err=0;
        List<Map<String,String>> userList = mkTestMapper.findUserList();
        int total=userList.size();
        for(Map<String,String> map :userList){
//            id,username
            String id = map.get("id");
            String username = map.get("username");
            String salt = oConvertUtils.randomGen(8);
            String password = PasswordUtil.encrypt(username, "caocao123", salt);
            int count = mkTestMapper.updatePass(password,salt,id);
            if(count>0){
                suc = suc+1;
            }else{
                err = err+1;
            }
        }
        return "总共有"+total+"；成功："+suc+"；失败："+err;
    }

    /**
     * 修改商品原价和商品现价
     * @return
     */
    @Override
    public String updGoodsSortsFromCcpt() {
        List<Map<String,String>> goods = mkTestMapper.findGoodsForUpdateSorts();
        // 成功
        int suc=0;
        // 失败
        int err=0;
        // 没有商品分类的商品数量
        int notSortsNum = 0;
        for (Map<String,String> map :goods){
            String goodsId = map.get("id");
            // 查询该商品的所有分类
            List<Map<String, String>> sortInfos = mkTestMapper.findSortByGoodsId(goodsId);
            String sorts = "";
            if(null!=sortInfos && sortInfos.size()>0){
                for (int i=0;i<sortInfos.size();i++){
                    Map<String,String> sort = sortInfos.get(i);
                    if(i==(sortInfos.size()-1)){
                        sorts = sorts+sort.get("sortId");
                    }else{
                        sorts = sorts+sort.get("sortId")+",";
                    }
                }
                int n = mkTestMapper.updateSortsByGoodsId(sorts,goodsId);
                if (n>0){suc=suc+1;}else{err=err+1;}
            }else{
                mkTestMapper.updateSortsByGoodsId("",goodsId);
                notSortsNum = notSortsNum+1;
            }
        }
        return "总共有"+goods.size()+"条商品，其中商品分类更新成功"+suc+"条，商品分类更新失败"+err+"条，没有商品分类的"+notSortsNum+"条";
    }

    /**
     * 根据经纬度调用高德接口查询该门店的省、市、县/区
     * @return
     */
    @Override
    public String updArea() {
        List<Map<String, String>> shops  =  mkTestMapper.findShopForArea();
        int suc=0,err=0;
        String sucMsg = "";
        String errMsg = "";
        for(Map<String, String> map : shops){
            String lngLat = map.get("lngLat");
            String id = map.get("id");
            String adcode = parseLocation(lngLat);
            if(adcode.length()<3){
                continue;
            }
            String[] adcodeArr = adcode.split(",");
            // 县/区  代码
            String areaAdcode = adcodeArr[0];
            // 市   代码
            String cityAdcode = adcodeArr[1];
            if(StringUtils.isBlank(areaAdcode) && StringUtils.isBlank(cityAdcode)){
                continue;
            }
            if(StringUtils.isNotBlank(adcode)){
                Map<String,String>  areaMap = new HashMap<>();
                if(StringUtils.isNotBlank(areaAdcode) && areaAdcode.length()>0){
                    areaMap = mkTestMapper.findArea(areaAdcode);
                }else{
                    areaMap = mkTestMapper.findCity(cityAdcode);
                }
                if(null!=areaMap && (areaMap.size()==3||areaMap.size()==2)) {
                    String provinceId = String.valueOf(areaMap.get("provinceId"));
                    String cityId = String.valueOf(areaMap.get("cityId"));
                    String areaId = String.valueOf(null==areaMap.get("areaId")?"":areaMap.get("areaId"));
                    // 更新mk_shop_basic表的 province    city    area
                    int num = mkTestMapper.updShopArea(provinceId, cityId, areaId, id);
                    if (num > 0) {
                        suc = suc + 1;
                        sucMsg = sucMsg + id + ",";
                    } else {
                        err = err + 1;
                        errMsg = errMsg + id + ",";
                    }
                }else{
                    err = err + 1;
                    errMsg = errMsg + id + ",";
                }
            }
        }
        return "成功："+suc+"个门店；"+sucMsg+"--------失败："+err+"个门店；"+errMsg;
    }

    public static void main(String[] args) {
        String str = "[{'name':'口味','values':['孜然','香辣','蜜汁','番茄','沙拉','黑椒']},{'name':'饮料','values':['红苹果','矿泉水']}]";
        List<Map<String,String>> list = change(str);
        for (Map<String,String> map :list){
            for(Map.Entry<String, String> vo : map.entrySet()){
                String key = vo.getKey();
                String value = vo.getValue();
                System.out.println("key:  "+key+"   value: "+value);
            }
        }

       // System.out.println(array.size());
    }
    private static  List<Map<String,String>> change(String str){
        JSONArray array = JSONUtil.parseArray(str);
        List<Map<String,String>> list = new ArrayList<>();
        for (Object obj:array){
            Map<String, String> map = new HashMap<>();
            JSONObject jsonObject = JSONUtil.parseObj(obj);
            String name = jsonObject.get("name").toString();
            String value = null==jsonObject.get("values")?"" : String.valueOf(jsonObject.get("values"));
            JSONArray valueArr = JSONUtil.parseArray(value);
            String values = "";
            for (Object valObj:valueArr){
                values = values+valObj.toString()+",";
            }

            values = values.substring(0,values.length()-1);
            map.put(name,values);
            list.add(map);
           // System.out.println("name: "+jsonObject.get("name")+"    value: "+ values);
        }
        return list;
    }
    /**
     * 店铺类型   对应  关系
     */
    private String findTypeStr(int type){
        //  1 6 7 全部对应周边美食
        //        //          2  对应  中外名酒
        //        //          3  对应  两性用品
        //        //          4   对应  蔬菜水果
        //        //          0 5 10   对应  综合超市
        //        //          8   对应  浪漫鲜花
        //        //          9   对应  蛋糕西点
        if(type==1 || type==6 || type==7){
            return "周边美食";
        }
        if(type==2){
            return "中外名酒";
        }
        if(type==3){
            return "两性用品";
        }
        if(type==4){
            return "蔬菜水果";
        }
        if(type==10 || type==0 || type==5){
            return "超市综合";
        }
        if(type==8){
            return "浪漫鲜花";
        }
        if(type==9){
            return "蛋糕西点";
        }
        return "超市综合";
    }

    /**
     * 调用高德接口返回县/区级的adcode
     */
    public static String parseLocation(String location){
        // https://lbs.amap.com/api/webservice/guide/api/georegeo 逆地址解析
        // amap_api 注册高德地图开发者，创建应用，获取apikey
        //测试key:8f21643950153e066e4bfefc3d244e19
        String key = "b8cc0845009644ee5e331702ca73249a";
        String url ="https://restapi.amap.com/v3/geocode/regeo?location="+location+"&key="+key+"&radius=1000&extensions=all";
        String jsonData =  HttpUtil.get(url);
        JSONObject jsonLocation = JSONUtil.parseObj(jsonData);
        String city = "",adcode="",cityCode="";
        if("1".equals(jsonLocation.getStr("status"))){
            JSONObject addressComponent =jsonLocation.getJSONObject("regeocode").getJSONObject("addressComponent");
            Object obj = null;
            if ((obj = addressComponent.get("province")) instanceof String){
                // 如果是直辖市，通过province返回数据
                city= city + (String)obj;
            }
            if((obj = addressComponent.get("city")) instanceof String){
                city= city + (String)obj;
                cityCode = addressComponent.get("adcode").toString();
            }
            if((obj = addressComponent.get("district")) instanceof String){
                city= city + (String)obj + addressComponent.get("adcode").toString();
                adcode =  addressComponent.get("adcode").toString();
            }

        }
        log.info("所属地："+city);
        return adcode+","+cityCode;
    }

}
